/**
 * 格式化时间
 * @param {Date|String|Number} date 时间
 * @param {String} format 格式化字符串
 * @returns {String} 格式化后的时间字符串
 */
export function formatTime(date, format = 'YYYY-MM-DD HH:mm:ss') {
  if (!date) return ''
  
  const d = new Date(date)
  const year = d.getFullYear()
  const month = String(d.getMonth() + 1).padStart(2, '0')
  const day = String(d.getDate()).padStart(2, '0')
  const hour = String(d.getHours()).padStart(2, '0')
  const minute = String(d.getMinutes()).padStart(2, '0')
  const second = String(d.getSeconds()).padStart(2, '0')
  
  return format
    .replace(/YYYY/g, year)
    .replace(/MM/g, month)
    .replace(/DD/g, day)
    .replace(/HH/g, hour)
    .replace(/mm/g, minute)
    .replace(/ss/g, second)
}

/**
 * 格式化相对时间
 * @param {Date|String|Number} date 时间
 * @returns {String} 相对时间字符串
 */
export function formatRelativeTime(date) {
  if (!date) return ''
  
  const now = new Date()
  const target = new Date(date)
  const diff = now - target
  
  const minute = 60 * 1000
  const hour = 60 * minute
  const day = 24 * hour
  const week = 7 * day
  const month = 30 * day
  
  if (diff < minute) {
    return '刚刚'
  } else if (diff < hour) {
    return `${Math.floor(diff / minute)}分钟前`
  } else if (diff < day) {
    return `${Math.floor(diff / hour)}小时前`
  } else if (diff < week) {
    return `${Math.floor(diff / day)}天前`
  } else if (diff < month) {
    return `${Math.floor(diff / week)}周前`
  } else {
    return formatTime(date, 'MM-DD')
  }
}

/**
 * 格式化薪资
 * @param {Number} min 最低薪资
 * @param {Number} max 最高薪资
 * @param {String} unit 单位（K、W）
 * @returns {String} 格式化后的薪资字符串
 */
export function formatSalary(min, max, unit = 'K') {
  if (!min && !max) return '面议'
  if (!max) return `${min}${unit}以上`
  if (!min) return `${max}${unit}以下`
  return `${min}-${max}${unit}`
}

/**
 * 格式化工作经验
 * @param {Number} experience 工作经验（年）
 * @returns {String} 格式化后的工作经验
 */
export function formatExperience(experience) {
  if (!experience || experience === 0) return '无经验要求'
  if (experience === 1) return '1年经验'
  return `${experience}年经验`
}

/**
 * 格式化学历
 * @param {String} education 学历代码
 * @returns {String} 学历名称
 */
export function formatEducation(education) {
  const educationMap = {
    'junior_high': '初中',
    'high_school': '高中',
    'technical_school': '中专/技校',
    'junior_college': '大专',
    'bachelor': '本科',
    'master': '硕士',
    'doctor': '博士'
  }
  return educationMap[education] || education
}

/**
 * 节流函数
 * @param {Function} func 要节流的函数
 * @param {Number} delay 延迟时间
 * @returns {Function} 节流后的函数
 */
export function throttle(func, delay = 1000) {
  let timer = null
  return function(...args) {
    if (!timer) {
      timer = setTimeout(() => {
        func.apply(this, args)
        timer = null
      }, delay)
    }
  }
}

/**
 * 防抖函数
 * @param {Function} func 要防抖的函数
 * @param {Number} delay 延迟时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, delay = 500) {
  let timer = null
  return function(...args) {
    clearTimeout(timer)
    timer = setTimeout(() => {
      func.apply(this, args)
    }, delay)
  }
}

/**
 * 深拷贝
 * @param {*} obj 要拷贝的对象
 * @returns {*} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj
  if (obj instanceof Date) return new Date(obj)
  if (obj instanceof Array) return obj.map(item => deepClone(item))
  if (typeof obj === 'object') {
    const clonedObj = {}
    for (let key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key])
      }
    }
    return clonedObj
  }
}

/**
 * 生成唯一ID
 * @returns {String} 唯一ID
 */
export function generateId() {
  return Date.now().toString(36) + Math.random().toString(36).substr(2)
}

/**
 * 验证手机号
 * @param {String} phone 手机号
 * @returns {Boolean} 是否有效
 */
export function isValidPhone(phone) {
  return /^1[3-9]\d{9}$/.test(phone)
}

/**
 * 验证邮箱
 * @param {String} email 邮箱
 * @returns {Boolean} 是否有效
 */
export function isValidEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)
}

/**
 * 验证身份证号
 * @param {String} idCard 身份证号
 * @returns {Boolean} 是否有效
 */
export function isValidIdCard(idCard) {
  return /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/.test(idCard)
}

/**
 * 获取文件扩展名
 * @param {String} filename 文件名
 * @returns {String} 扩展名
 */
export function getFileExtension(filename) {
  return filename.slice((filename.lastIndexOf('.') - 1 >>> 0) + 2)
}

/**
 * 格式化文件大小
 * @param {Number} bytes 字节数
 * @returns {String} 格式化后的文件大小
 */
export function formatFileSize(bytes) {
  if (bytes === 0) return '0 B'
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 检查是否是微信环境
 * @returns {Boolean} 是否是微信环境
 */
export function isWeChat() {
  return /MicroMessenger/i.test(navigator.userAgent)
}

/**
 * 检查是否是移动设备
 * @returns {Boolean} 是否是移动设备
 */
export function isMobile() {
  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)
}

/**
 * 格式化距离
 * @param {Number} distance 距离（米）
 * @returns {String} 格式化后的距离
 */
export function formatDistance(distance) {
  if (!distance) return ''
  if (distance < 1000) {
    return `${distance}m`
  }
  return `${(distance / 1000).toFixed(1)}km`
}

/**
 * 获取技能颜色
 * @param {String} skill 技能名称
 * @returns {String} 颜色值
 */
export function getSkillColor(skill) {
  const colorMap = {
    'Python': '#3776ab',
    'Java': '#ed8b00',
    'JavaScript': '#f7df1e',
    'Vue.js': '#4fc08d',
    'React': '#61dafb',
    'Node.js': '#339933',
    'PHP': '#777bb4',
    'Go': '#00add8',
    'MySQL': '#4479a1',
    'Redis': '#dc382d'
  }
  return colorMap[skill] || '#666666'
}

/**
 * 计算简历完整度
 * @param {Object} resume 简历对象
 * @returns {Number} 完整度百分比
 */
export function calculateResumeCompleteness(resume) {
  if (!resume) return 0
  
  const fields = [
    'name', 'phone', 'email', 'avatar',
    'workExperience', 'education', 'skills', 'projectExperience'
  ]
  
  let completedFields = 0
  
  fields.forEach(field => {
    if (resume[field]) {
      if (Array.isArray(resume[field])) {
        if (resume[field].length > 0) completedFields++
      } else {
        completedFields++
      }
    }
  })
  
  return Math.round((completedFields / fields.length) * 100)
}

/**
 * 高亮搜索关键词
 * @param {String} text 文本
 * @param {String} keyword 关键词
 * @returns {String} 高亮后的HTML
 */
export function highlightKeyword(text, keyword) {
  if (!keyword) return text
  const regex = new RegExp(`(${keyword})`, 'gi')
  return text.replace(regex, '<span class="highlight">$1</span>')
}

/**
 * 处理图片懒加载
 * @param {String} src 图片地址
 * @param {String} placeholder 占位图地址
 * @returns {Object} 懒加载配置
 */
export function createLazyImage(src, placeholder = '/static/images/placeholder.png') {
  return {
    src: placeholder,
    'data-src': src,
    loading: 'lazy'
  }
}

/**
 * 判断是否为有效的URL
 * @param {String} url URL字符串
 * @returns {Boolean} 是否有效
 */
export function isValidUrl(url) {
  try {
    new URL(url)
    return true
  } catch {
    return false
  }
}